/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package org.osiris.persistence;

import java.io.Serializable;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Observable;

import javax.annotation.Resource;
import javax.persistence.Basic;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

import org.apache.log4j.Logger;
import org.osiris.client.model.CategoriaViewBean;
import org.osiris.client.model.ComplejidadrequisitoViewBean;
import org.osiris.client.model.EstadorequisitoViewBean;
import org.osiris.client.model.RequisitoViewBean;
import org.osiris.client.model.TipoRequisitoViewBean;
import org.osiris.client.model.UsuarioViewBean;
import org.osiris.persistence.controllers.EstadoInterface;
import org.osiris.persistence.controllers.RelacionRequisitoInterface;
import org.osiris.persistence.controllers.RequisitoInterface;
import org.osiris.persistence.controllers.RiesgoInterface;
import org.osiris.persistence.controllers.exceptions.IllegalOrphanException;
import org.osiris.persistence.controllers.exceptions.NonexistentEntityException;
import org.osiris.persistence.controllers.exceptions.PreexistingEntityException;
import org.osiris.persistence.controllers.impl.TiposderelacionJpaController;
import org.osiris.server.utils.AppContext;
import org.springframework.context.ApplicationContext;

/**
 *
 * @author amartinez
 */
@Entity
@Table(name = "Requisito")
@NamedQueries({@NamedQuery(name = "Requisito.findAll", query = "SELECT r FROM Requisito r"), @NamedQuery(name = "Requisito.findByIdRequisito", query = "SELECT r FROM Requisito r WHERE r.idRequisito = :idRequisito"), @NamedQuery(name = "Requisito.findByPuntosFuncion", query = "SELECT r FROM Requisito r WHERE r.puntosFuncion = :puntosFuncion"), @NamedQuery(name = "Requisito.findByNombre", query = "SELECT r FROM Requisito r WHERE r.nombre = :nombre"), @NamedQuery(name = "Requisito.findByReferencia", query = "SELECT r FROM Requisito r WHERE r.referencia = :referencia"), @NamedQuery(name = "Requisito.findByFechaalta", query = "SELECT r FROM Requisito r WHERE r.fechaalta = :fechaalta"), @NamedQuery(name = "Requisito.findByFechabaja", query = "SELECT r FROM Requisito r WHERE r.fechabaja = :fechabaja"), @NamedQuery(name = "Requisito.findByDescripcion", query = "SELECT r FROM Requisito r WHERE r.descripcion = :descripcion")})
public class Requisito extends Observable implements Serializable {
    private static final long serialVersionUID = 1L;
    
    @Transient
	@Resource
	private RequisitoInterface requisitoDAO;
	@Transient
	@Resource
	private EstadoInterface estadoDAO;
	
	@Transient
	private Logger logger = Logger.getLogger(this.getClass());
	
	
	@Transient
	@Resource
	private TiposderelacionJpaController TiposderelacionJpaController;
	@Transient
	@Resource
	private RelacionRequisitoInterface relacionesRequisitoDAO;
	@Transient
	@Resource
	private RiesgoInterface riesgoDAO;
	@Transient
	private static Long STATUS_DESIGN = 1L;
	@Transient
	private static Long STATUS_NEW = 2L;
	@Transient
	private static Long STATUS_ACCEPT = 3L;
	@Transient
	private static Long STATUS_REJECTED = 4L;
	@Transient
	private ApplicationContext ctx = AppContext.getApplicationContext();
	@Transient
	private static int ASOCIARG=1;
	@Transient
	private static int DESASOCIARG=2;
	@Transient
	private static int ASOCIARQ=3;
	
	private static int DesASOCIARQ=4;

	@Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Basic(optional = false)
    @Column(name = "idRequisito")
    private Long idRequisito;

	@Column(name = "PuntosFuncion")
    private Integer puntosFuncion;

	@Basic(optional = false)
    @Column(name = "Nombre")
    private String nombre;

	@Basic(optional = false)
    @Column(name = "Referencia")
    private String referencia;

	@Basic(optional = false)
    @Column(name = "Fecha_alta")
    @Temporal(TemporalType.TIMESTAMP)
    private Date fechaalta;

	@Column(name = "Fecha_baja")
    @Temporal(TemporalType.TIMESTAMP)
    private Date fechabaja;

	@Basic(optional = false)
    @Column(name = "Descripcion")
    private String descripcion;

	@OneToMany(cascade = CascadeType.ALL, mappedBy = "idRequisito", fetch = FetchType.EAGER)
	private List<Riesgo> riesgoList;
	
	
	@JoinColumn(name = "idEstadoRequisito", referencedColumnName = "idEstadoRequisito")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Estadorequisito idEstadoRequisito;
	@JoinColumn(name = "idSubcategoria", referencedColumnName = "idSubcategoria")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Subcategoria idSubcategoria;

	@JoinColumn(name = "Responsable", referencedColumnName = "idUsuario")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Usuario responsable;

	@JoinColumn(name = "idTipoRequisito", referencedColumnName = "idTipoRequisito")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Tiporequisito idTipoRequisito;

	@JoinColumn(name = "Autor", referencedColumnName = "idUsuario")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Usuario autor;
    @JoinColumn(name = "idComplejidadRequisito", referencedColumnName = "idComplejidadRequisito")
    @ManyToOne(optional = false, fetch = FetchType.EAGER)
    private Complejidadrequisito idComplejidadRequisito;
    @OneToOne(cascade = CascadeType.ALL, mappedBy = "requisito", fetch = FetchType.LAZY)
    private Detallerequisito detallerequisito;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "requisito", fetch = FetchType.LAZY)
    private List<Requisitosdeproyecto> requisitosdeproyectoList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "idRequisitoorigen", fetch = FetchType.LAZY)
    private List<Modificaciondeec> modificaciondeecList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "idRequisitodestino", fetch = FetchType.LAZY)
    private List<Modificaciondeec> modificaciondeecCollection1;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "idRequisito", fetch = FetchType.LAZY)
    private List<Impactocambio> impactocambioList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "requisito", fetch = FetchType.LAZY)
    private List<Recursosderequisito> recursosderequisitoList;
    
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "requisito", fetch = FetchType.LAZY)
    private List<Relacionrequisito> relacionrequisitoList;
    
    
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "requisito1", fetch = FetchType.LAZY)
    private List<Relacionrequisito> relacionrequisitoCollection1;
    public Requisito() {
    }
    public Requisito(Long idRequisito) {
        this.idRequisito = idRequisito;
        
    }
    public Requisito(Long idRequisito, String nombre, String referencia, Date fechaalta, String descripcion) {
        this.idRequisito = idRequisito;
        this.nombre = nombre;
        this.referencia = referencia;
        this.fechaalta = fechaalta;
        this.descripcion = descripcion;
    }
    public boolean aceptar() {
		this.setIdEstadoRequisito(this.estadoDAO.findEstadorequisito(STATUS_ACCEPT));
		this.modificar();
		this.notifyObservers("EstadoAceptado");
		return true;
	}
    public void anadirInteresado(Usuario user){
		this.addObserver(user);
	}
    /**
	 * Asigna que este requisito depende del requisito pasado como parametro
	 * 
	 * @param pRequisito
     * @throws Exception 
	 */
	public void asignarNuevoRequisitoDependiente(Requisito pRequisito, Long pIdTiposDeRelacion) throws Exception {
		logger.info("Creando nueva relacion ara el requisito:"+this.getIdRequisito()+" con "+pRequisito.getIdRequisito()+" de tipo "+pIdTiposDeRelacion);
		inicializarControllers();
		anadirObservadores();
		this.compruebaEstado(ASOCIARQ);
		Relacionrequisito relacionDeDependencia = new Relacionrequisito();
		RelacionrequisitoPK relacionrequisitoPK = new RelacionrequisitoPK();
		relacionrequisitoPK.setIdTiposDeRelacion(pIdTiposDeRelacion);
		relacionrequisitoPK.setRequisitodestino(pRequisito.getIdRequisito());
		relacionrequisitoPK.setRequisitoorigen(this.getIdRequisito());
		relacionDeDependencia.setRelacionrequisitoPK(relacionrequisitoPK);
		relacionDeDependencia.setTiposderelacion(this.TiposderelacionJpaController.findTiposderelacion(pIdTiposDeRelacion));
		relacionDeDependencia.setRequisito(this);
		relacionDeDependencia.setRequisito1(pRequisito);
		try {
			this.relacionesRequisitoDAO.create(relacionDeDependencia);
		} catch (PreexistingEntityException e1) {
			e1.printStackTrace();
		} catch (Exception e1) {
			e1.printStackTrace();
		}

		//this.getRelacionrequisitoList().add(relacionDeDependencia);
		//pRequisito.getRelacionrequisitoList().add(relacionDeDependencia);
		this.notifyObservers("NuevaDependencia");
	}
	public void anadirObservadores(){
			logger.info("anadirObservadores empieza...");
			this.deleteObservers();
			this.addObserver(this.getAutor());
			logger.info("Added observer:"+this.getAutor().getIdUsuario());
			this.addObserver(this.getResponsable());
			logger.info("Added observer:"+this.getResponsable().getIdUsuario());
			
			logger.info("anadirObservadores termina...");
		
		
	}
    /**
	 * Asigna y guarda en db, el riesgo pasado como parametro al requisito
	 * 
	 * @param pRiesgo
	 */
	public Riesgo asociarNuevoRiesgoDependiente(String descripcion,String nombre, Long usuario, String impacto, String probabilidad){
		
		inicializarControllers();
		anadirObservadores();
		Riesgo pRiesgo=null;
		try{
			pRiesgo=new Riesgo(this,descripcion, nombre,  usuario,  impacto,  probabilidad);
		this.getRiesgoList().add(pRiesgo);
			
		}catch(Exception me){}
		try{
		pRiesgo.guardar();
		}catch(Exception me){}
		try{
			logger.info("Notificando a todos los observadores");
			this.setChanged();
			this.notifyObservers("NuevoRiesgo");
		this.notifyObservers();
		
		logger.info("Notificados");
		}catch(Exception me){me.printStackTrace();}
		return pRiesgo;
	}
    public boolean bloquear() {
		return true;
	}
    /**
	 * Guarda el requisito por primera vez en la base de datos
	 */
	public void crear() {
		inicializarControllers();
		logger.info("Guardando requisito en BD...");
		try {
			requisitoDAO.create(this);
			logger.info("Guardado OK en db");
						this.notifyObservers("RequisitoCreado");
		} catch (Exception e) {
			logger.info("Error guardando el requisito:" + e.toString());
			e.printStackTrace();
		}
	}
    public void desasociar(Long riesgo) throws Exception {
        	this.compruebaEstado(DESASOCIARG);
    	inicializarControllers();
		logger.info("Eliminando riesgo:"+riesgo+" ....");
		try {
			riesgoDAO.destroy(riesgo);
			this.notifyObservers("RiesgoEliminado");
		} catch (NonexistentEntityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
			logger.info("Error eliminado riesgo");
		}
		logger.info("Riesgo eliminado");
		
		
	}
    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Requisito)) {
            return false;
        }
        Requisito other = (Requisito) object;
        if ((this.idRequisito == null && other.idRequisito != null) || (this.idRequisito != null && !this.idRequisito.equals(other.idRequisito))) {
            return false;
        }
        return true;
    }
    public boolean estimar(int puntosDeFuncion) {
		return true;

	}
    public Usuario getAutor() {
        return autor;
    }
    public String getDescripcion() {
        return descripcion;
    }

    public Detallerequisito getDetallerequisito() {
        return detallerequisito;
    }

    public Date getFechaalta() {
        return fechaalta;
    }

    public Date getFechabaja() {
        return fechabaja;
    }

    public Complejidadrequisito getIdComplejidadRequisito() {
        return idComplejidadRequisito;
    }

    public Estadorequisito getIdEstadoRequisito() {
        return idEstadoRequisito;
    }

    public Long getIdRequisito() {
        return idRequisito;
    }

    public Subcategoria getIdSubcategoria() {
        return idSubcategoria;
    }

    public Tiporequisito getIdTipoRequisito() {
        return idTipoRequisito;
    }

    public List<Impactocambio> getImpactocambioList() {
        return impactocambioList;
    }

    public List<Modificaciondeec> getModificaciondeecCollection1() {
        return modificaciondeecCollection1;
    }

    public List<Modificaciondeec> getModificaciondeecList() {
        return modificaciondeecList;
    }

    public String getNombre() {
        return nombre;
    }

    /**
	 * Cuenta proyectos
	 * 
	 * @return numero de proyectos que incluyen este requisito
	 */
	public int getNumProyectosDependientes() {
		return this.getRequisitosdeproyectoList().size();
	}

    /**
	 * Calcula la probabilidad de que se materalicen riesgos IDEPENDIENTES asociados al reguisito.
	 * 
	 * Hay que tener en cuenta que los riesgos son independientes entre s� para poder aplicar
	 * el principio de conteo aditivo.
	 * Si fuesen riesgos que dependen unos de otros, el c�lculo de la probabilidad ser�a m�s
	 * complejo ya que se deber�an calcular las probabilidades condicionadas.
	 * 
	 * {pre: los riesgos deben ser totalmente independientes entre si}
	 * @return probabilidad de que se materialicen riesgos INDEPENDIENTES
	 */
	public double GetProbabilidadMaterializacionRiesgos(){
		double exposicionCompuesta=0.0;

		for (Riesgo unRiesgo : this.getRiesgoList()) {
			//suma+=unRiesgo.getProbabilidad();
			exposicionCompuesta += (unRiesgo.getImpacto()*unRiesgo.getProbabilidad());
		}	
		return exposicionCompuesta;
	}

    /**
	 * Calcula la probabilidad de que se materalicen TODOS los riesgos IDEPENDIENTES asociados al reguisito.
	 * 
	 * Hay que tener en cuenta que los riesgos son independientes entre s� para poder aplicar
	 * el principio de conteo multiplicativo.
	 * Si fuesen riesgos que dependen unos de otros, el c�lculo de la probabilidad ser�a m�s
	 * complejo ya que se deber�an calcular las probabilidades condicionadas.
	 * 
	 * {pre: los riesgos deben ser totalmente independientes entre si}
	 * @return probabilidad de que se materialicen TODOS los riesgos INDEPENDIENTES
	 */
	public double GetProbabilidadMaterializacionTodosLosRiesgos(){
		double prod=0.0;

		for (Riesgo unRiesgo : this.getRiesgoList()) {
			//prod*=unRiesgo.getProbabilidad();
		}	
		return prod;
	}

    public Integer getPuntosFuncion() {
        return puntosFuncion;
    }

    public List<Recursosderequisito> getRecursosderequisitoList() {
        return recursosderequisitoList;
    }

    public String getReferencia() {
        return referencia;
    }

    public List<Relacionrequisito> getRelacionrequisitoCollection1() {
        return relacionrequisitoCollection1;
    }

    public List<Relacionrequisito> getRelacionrequisitoList() {
        return relacionrequisitoList;
    }

    public List<Requisitosdeproyecto> getRequisitosdeproyectoList() {
        return requisitosdeproyectoList;
    }

    public Usuario getResponsable() {
        return responsable;
    }

    public List<Riesgo> getRiesgoList() {
        return riesgoList;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (idRequisito != null ? idRequisito.hashCode() : 0);
        return hash;
    }

    public void inicializarControllers(){
    	if (relacionesRequisitoDAO == null) {
			relacionesRequisitoDAO = (RelacionRequisitoInterface) ctx.getBean("RelacionrequisitoJpaController");
		}
		if (estadoDAO == null) {
			estadoDAO = (EstadoInterface) ctx.getBean("EstadorequisitoJpaController");
		}
		if (requisitoDAO == null) {
			requisitoDAO = (RequisitoInterface) ctx.getBean("RequisitoJpaController");
		}
		if (requisitoDAO == null) {
			requisitoDAO = (RequisitoInterface) ctx.getBean("RequisitoJpaController");
		}
		if (riesgoDAO == null) {
			riesgoDAO = (RiesgoInterface) ctx.getBean("RiesgoJpaController");
		}
		if (TiposderelacionJpaController == null) {
			TiposderelacionJpaController = (TiposderelacionJpaController) ctx.getBean("TiposderelacionJpaController");
		}
		
    }

    /**
	 * Modifica el requisito en db
	 * 
	 */
	public void modificar() {
		inicializarControllers();
		logger.info("Modificando requisito en BD");
		try {
			requisitoDAO.edit(this);
			this.notifyObservers("Modificacion");
			logger.info("Modificacion OK en db");
		} catch (IllegalOrphanException e) {
			e.printStackTrace();
		} catch (NonexistentEntityException e) {
			logger.info("Error modificando el requisito:" + e.toString());
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

    public boolean rechazar() {
		this.setIdEstadoRequisito(this.estadoDAO.findEstadorequisito(this.STATUS_REJECTED));
		this.modificar();
		this.notifyObservers("Rechazo");
		
		// si me encuentro rechazado no envio ningun mensaje
		this.deleteObservers();
		return true;
	}

    public void setAutor(Usuario autor) {
        this.autor = autor;
    }

    public void setDescripcion(String descripcion) {
        this.descripcion = descripcion;
    }

    public void setDetallerequisito(Detallerequisito detallerequisito) {
        this.detallerequisito = detallerequisito;
    }

    public void setFechaalta(Date fechaalta) {
        this.fechaalta = fechaalta;
    }

    public void setFechabaja(Date fechabaja) {
        this.fechabaja = fechabaja;
    }

    public void setIdComplejidadRequisito(Complejidadrequisito idComplejidadRequisito) {
        this.idComplejidadRequisito = idComplejidadRequisito;
    }

    public void setIdEstadoRequisito(Estadorequisito idEstadoRequisito) {
        this.idEstadoRequisito = idEstadoRequisito;
    }

    public void setIdRequisito(Long idRequisito) {
        this.idRequisito = idRequisito;
    }

    public void setIdSubcategoria(Subcategoria idSubcategoria) {
        this.idSubcategoria = idSubcategoria;
    }

    public void setIdTipoRequisito(Tiporequisito idTipoRequisito) {
        this.idTipoRequisito = idTipoRequisito;
    }

    public void setImpactocambioList(List<Impactocambio> impactocambioList) {
        this.impactocambioList = impactocambioList;
    }

    public void setModificaciondeecCollection1(List<Modificaciondeec> modificaciondeecCollection1) {
        this.modificaciondeecCollection1 = modificaciondeecCollection1;
    }

    public void setModificaciondeecList(List<Modificaciondeec> modificaciondeecList) {
        this.modificaciondeecList = modificaciondeecList;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public void setPuntosFuncion(Integer puntosFuncion) {
        this.puntosFuncion = puntosFuncion;
    }

    public void setRecursosderequisitoList(List<Recursosderequisito> recursosderequisitoList) {
        this.recursosderequisitoList = recursosderequisitoList;
    }

    public void setReferencia(String referencia) {
        this.referencia = referencia;
    }

    public void setRelacionrequisitoCollection1(List<Relacionrequisito> relacionrequisitoCollection1) {
        this.relacionrequisitoCollection1 = relacionrequisitoCollection1;
    }

    public void setRelacionrequisitoList(List<Relacionrequisito> relacionrequisitoList) {
        this.relacionrequisitoList = relacionrequisitoList;
    }

    public void setRequisitosdeproyectoList(List<Requisitosdeproyecto> requisitosdeproyectoList) {
        this.requisitosdeproyectoList = requisitosdeproyectoList;
    }

    public void setResponsable(Usuario responsable) {
        this.responsable = responsable;
    }

    public void setRiesgoList(List<Riesgo> riesgoList) {
        this.riesgoList = riesgoList;
    }

    @Override
    public String toString() {
        return "org.osiris.persistence.Requisito[idRequisito=" + idRequisito + "]";
    }
	public RequisitoViewBean toView() {
    	inicializarControllers();
		RequisitoViewBean req = new RequisitoViewBean();
		req.setautor(this.getAutor().getNombre()+" "+this.getAutor().getPrimerApellido());
		req.setdescripcion(this.getDescripcion());
		if(this.getDetallerequisito()!=null){
			req.setdetallerequisito(this.getDetallerequisito().getDetalle());
		}
		req.setfechaalta(this.getFechaalta());
		req.setidComplejidadRequisito(new ComplejidadrequisitoViewBean(this.getIdComplejidadRequisito().getIdComplejidadRequisito(), this.getIdComplejidadRequisito().getValor()));
		req.setidEstadoRequisito(new EstadorequisitoViewBean(this.getIdEstadoRequisito().getIdEstadoRequisito(), this.getIdEstadoRequisito().getValor()));
		req.setidRequisito(this.getIdRequisito());
		req.setidTipoRequisito(new TipoRequisitoViewBean(this.getIdTipoRequisito().getIdTipoRequisito(), this.getIdTipoRequisito().getValor()));
		req.setnombre(this.getNombre());
		if(this.getDetallerequisito()!=null){
			req.setorigen(this.getDetallerequisito().getOrigen());
		}
		req.setpuntosFuncion(this.getPuntosFuncion());
		req.setreferencia(this.getReferencia());
		
		UsuarioViewBean User=new UsuarioViewBean();
		User.setnombre(this.getResponsable().getNombre());
		User.setprimerApellido(this.getResponsable().getPrimerApellido());
		User.setidUsuario(this.getResponsable().getIdUsuario());
		req.setresponsable(User);
		Subcategoria cat = this.getIdSubcategoria();
		CategoriaViewBean padre=null;
		Categoria catpa = cat.getIdCategoria();
		try{
		padre=new CategoriaViewBean(catpa.getIdCategoria(), 
				catpa.getValor(), 
				null);
		}catch(Exception me){
			me.printStackTrace();
		}
		req.setsubcategoria(
				new CategoriaViewBean(cat.getIdSubcategoria(),
						cat.getValor(), 
						padre));
		
		return req;

	}
	public String comoEstas() {
		
		String mensaje=this.nombre;
		int difDias=0;
		Calendar fechaActual= Calendar.getInstance();
		// crear la logica de las fechas para la respta de las fechas
		//difDias=fechaActual-fechaRequisito	
		
		if(this.getIdEstadoRequisito().getIdEstadoRequisito()== STATUS_NEW){
		if( difDias >6 && difDias<15)
		{
			mensaje+="7 dias en estado nuevo";
		}
		if(difDias>15)
		{
			mensaje+="15 dias en estado nuevo, cambio a rechazado";
			this.getIdEstadoRequisito().setIdEstadoRequisito(STATUS_REJECTED);
		}
		
		//Futurible, guardar en la BBDD fecha del ultimo cambio o del ultimo acceso de responsable
		// para ver si se usa o no el requisito
		
		}
		return mensaje;
		
	}
	/**
	 * 
	 * @param accion, 1 Asociar Riesgo, 2 Desasociar un Riesgo, 3 Asociar un RQ, 4 desasociar RQ
	 * Regla: toda accion incompatible con los estados NUEVO o RECHAZADO ser� mayor que 0
	 * @throws Exception
	 */
	private void compruebaEstado(int accion) throws Exception{
		
		if(this.getIdEstadoRequisito().getIdEstadoRequisito()==STATUS_NEW){
			if(accion>0) {   // accion 1 es asociar Riesgo, accion 2 es asociar un requisito	
				throw new Exception("Requisito en estado NUEVO, accion no compatible");
			}
		}
		if(this.getIdEstadoRequisito().getIdEstadoRequisito()==STATUS_REJECTED){
			if(accion>0 ) {   // accion 1 es asociar Riesgo, accion 2 es asociar un requisito	
				throw new Exception("Requisito en estado RECHAZADO, accion no compatible");
			}
		}
	}
	public void quitarProyectoObservador(Proyecto proyecto) {
		this.deleteObserver(proyecto);
		
	}
	public void anadirProyectoObservador(Proyecto proyecto) {
		this.addObserver(proyecto);
		
	}
	public void desasignarNuevoRequisitoDependiente(Requisito requisito) {
		
		logger.info("Eliminando relacion para el requisito:"+this.getIdRequisito()+" con "+requisito.getIdRequisito());
		inicializarControllers();
		anadirObservadores();
		Relacionrequisito rel = this.relacionesRequisitoDAO.findDependencia(this.getIdRequisito(), requisito.getIdRequisito());
		try {
			this.relacionesRequisitoDAO.destroy(rel.getRelacionrequisitoPK());
		} catch (NonexistentEntityException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		this.notifyObservers("NuevaDependencia");
		
	}
		
		
		
		


}
